home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_importhooks.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  8.0 KB  |  251 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import sys
  5. import imp
  6. import os
  7. import unittest
  8. from test import test_support
  9. test_src = 'def get_name():\n    return __name__\ndef get_file():\n    return __file__\n'
  10. reload_src = test_src + 'reloaded = True\n'
  11. test_co = compile(test_src, '<???>', 'exec')
  12. reload_co = compile(reload_src, '<???>', 'exec')
  13. test_path = '!!!_test_!!!'
  14.  
  15. class ImportTracker:
  16.     '''Importer that only tracks attempted imports.'''
  17.     
  18.     def __init__(self):
  19.         self.imports = []
  20.  
  21.     
  22.     def find_module(self, fullname, path = None):
  23.         self.imports.append(fullname)
  24.  
  25.  
  26.  
  27. class TestImporter:
  28.     modules = {
  29.         'hooktestmodule': (False, test_co),
  30.         'hooktestpackage': (True, test_co),
  31.         'hooktestpackage.sub': (True, test_co),
  32.         'hooktestpackage.sub.subber': (False, test_co),
  33.         'reloadmodule': (False, test_co) }
  34.     
  35.     def __init__(self, path = test_path):
  36.         if path != test_path:
  37.             raise ImportError
  38.         
  39.         self.path = path
  40.  
  41.     
  42.     def _get__path__(self):
  43.         raise NotImplementedError
  44.  
  45.     
  46.     def find_module(self, fullname, path = None):
  47.         if fullname in self.modules:
  48.             return self
  49.         else:
  50.             return None
  51.  
  52.     
  53.     def load_module(self, fullname):
  54.         (ispkg, code) = self.modules[fullname]
  55.         mod = sys.modules.setdefault(fullname, imp.new_module(fullname))
  56.         mod.__file__ = '<%s>' % self.__class__.__name__
  57.         mod.__loader__ = self
  58.         if ispkg:
  59.             mod.__path__ = self._get__path__()
  60.         
  61.         exec code in mod.__dict__
  62.         return mod
  63.  
  64.  
  65.  
  66. class MetaImporter(TestImporter):
  67.     
  68.     def _get__path__(self):
  69.         return []
  70.  
  71.  
  72.  
  73. class PathImporter(TestImporter):
  74.     
  75.     def _get__path__(self):
  76.         return [
  77.             self.path]
  78.  
  79.  
  80.  
  81. class ImportBlocker:
  82.     """Place an ImportBlocker instance on sys.meta_path and you
  83.     can be sure the modules you specified can't be imported, even
  84.     if it's a builtin."""
  85.     
  86.     def __init__(self, *namestoblock):
  87.         self.namestoblock = dict.fromkeys(namestoblock)
  88.  
  89.     
  90.     def find_module(self, fullname, path = None):
  91.         if fullname in self.namestoblock:
  92.             return self
  93.         
  94.  
  95.     
  96.     def load_module(self, fullname):
  97.         raise ImportError, 'I dare you'
  98.  
  99.  
  100.  
  101. class ImpWrapper:
  102.     
  103.     def __init__(self, path = None):
  104.         if path is not None and not os.path.isdir(path):
  105.             raise ImportError
  106.         
  107.         self.path = path
  108.  
  109.     
  110.     def find_module(self, fullname, path = None):
  111.         subname = fullname.split('.')[-1]
  112.         if subname != fullname and self.path is None:
  113.             return None
  114.         
  115.         if self.path is None:
  116.             path = None
  117.         else:
  118.             path = [
  119.                 self.path]
  120.         
  121.         try:
  122.             (file, filename, stuff) = imp.find_module(subname, path)
  123.         except ImportError:
  124.             return None
  125.  
  126.         return ImpLoader(file, filename, stuff)
  127.  
  128.  
  129.  
  130. class ImpLoader:
  131.     
  132.     def __init__(self, file, filename, stuff):
  133.         self.file = file
  134.         self.filename = filename
  135.         self.stuff = stuff
  136.  
  137.     
  138.     def load_module(self, fullname):
  139.         mod = imp.load_module(fullname, self.file, self.filename, self.stuff)
  140.         if self.file:
  141.             self.file.close()
  142.         
  143.         mod.__loader__ = self
  144.         return mod
  145.  
  146.  
  147.  
  148. class ImportHooksBaseTestCase(unittest.TestCase):
  149.     
  150.     def setUp(self):
  151.         self.path = sys.path[:]
  152.         self.meta_path = sys.meta_path[:]
  153.         self.path_hooks = sys.path_hooks[:]
  154.         sys.path_importer_cache.clear()
  155.         self.tracker = ImportTracker()
  156.         sys.meta_path.insert(0, self.tracker)
  157.  
  158.     
  159.     def tearDown(self):
  160.         sys.path[:] = self.path
  161.         sys.meta_path[:] = self.meta_path
  162.         sys.path_hooks[:] = self.path_hooks
  163.         sys.path_importer_cache.clear()
  164.         for fullname in self.tracker.imports:
  165.             if fullname in sys.modules:
  166.                 del sys.modules[fullname]
  167.                 continue
  168.         
  169.  
  170.  
  171.  
  172. class ImportHooksTestCase(ImportHooksBaseTestCase):
  173.     
  174.     def doTestImports(self, importer = None):
  175.         import hooktestmodule
  176.         import hooktestpackage
  177.         import hooktestpackage.sub as hooktestpackage
  178.         import hooktestpackage.sub.subber as hooktestpackage
  179.         self.assertEqual(hooktestmodule.get_name(), 'hooktestmodule')
  180.         self.assertEqual(hooktestpackage.get_name(), 'hooktestpackage')
  181.         self.assertEqual(hooktestpackage.sub.get_name(), 'hooktestpackage.sub')
  182.         self.assertEqual(hooktestpackage.sub.subber.get_name(), 'hooktestpackage.sub.subber')
  183.         if importer:
  184.             self.assertEqual(hooktestmodule.__loader__, importer)
  185.             self.assertEqual(hooktestpackage.__loader__, importer)
  186.             self.assertEqual(hooktestpackage.sub.__loader__, importer)
  187.             self.assertEqual(hooktestpackage.sub.subber.__loader__, importer)
  188.         
  189.         TestImporter.modules['reloadmodule'] = (False, test_co)
  190.         import reloadmodule
  191.         self.failIf(hasattr(reloadmodule, 'reloaded'))
  192.         TestImporter.modules['reloadmodule'] = (False, reload_co)
  193.         reload(reloadmodule)
  194.         self.failUnless(hasattr(reloadmodule, 'reloaded'))
  195.  
  196.     
  197.     def testMetaPath(self):
  198.         i = MetaImporter()
  199.         sys.meta_path.append(i)
  200.         self.doTestImports(i)
  201.  
  202.     
  203.     def testPathHook(self):
  204.         sys.path_hooks.append(PathImporter)
  205.         sys.path.append(test_path)
  206.         self.doTestImports()
  207.  
  208.     
  209.     def testBlocker(self):
  210.         mname = 'exceptions'
  211.         if mname in sys.modules:
  212.             del sys.modules[mname]
  213.         
  214.         sys.meta_path.append(ImportBlocker(mname))
  215.         
  216.         try:
  217.             __import__(mname)
  218.         except ImportError:
  219.             pass
  220.  
  221.         self.fail("'%s' was not supposed to be importable" % mname)
  222.  
  223.     
  224.     def testImpWrapper(self):
  225.         i = ImpWrapper()
  226.         sys.meta_path.append(i)
  227.         sys.path_hooks.append(ImpWrapper)
  228.         mnames = ('colorsys', 'urlparse', 'distutils.core', 'compiler.misc')
  229.         for mname in mnames:
  230.             parent = mname.split('.')[0]
  231.             for n in sys.modules.keys():
  232.                 if n.startswith(parent):
  233.                     del sys.modules[n]
  234.                     continue
  235.             
  236.         
  237.         for mname in mnames:
  238.             m = __import__(mname, globals(), locals(), [
  239.                 '__dummy__'])
  240.             m.__loader__
  241.         
  242.  
  243.  
  244.  
  245. def test_main():
  246.     test_support.run_unittest(ImportHooksTestCase)
  247.  
  248. if __name__ == '__main__':
  249.     test_main()
  250.  
  251.